{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:08.125203900Z",
     "start_time": "2024-04-29T02:49:56.553689Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:00.425747Z",
     "iopub.status.busy": "2025-01-21T13:55:00.425382Z",
     "iopub.status.idle": "2025-01-21T13:55:02.562212Z",
     "shell.execute_reply": "2025-01-21T13:55:02.561687Z",
     "shell.execute_reply.started": "2025-01-21T13:55:00.425719Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=10, micro=14, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cu124\n",
      "cuda:0\n"
     ]
    }
   ],
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "    \n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)\n",
    "\n",
    "seed = 42\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据准备\n",
    "\n",
    "https://www.kaggle.com/competitions/cifar-10/data\n",
    "\n",
    "```shell\n",
    "$ tree -L 1 cifar-10                                    \n",
    "cifar-10\n",
    "├── sampleSubmission.csv\n",
    "├── test\n",
    "├── train\n",
    "└── trainLabels.csv\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:02.563380Z",
     "iopub.status.busy": "2025-01-21T13:55:02.563101Z",
     "iopub.status.idle": "2025-01-21T13:55:02.565791Z",
     "shell.execute_reply": "2025-01-21T13:55:02.565323Z",
     "shell.execute_reply.started": "2025-01-21T13:55:02.563358Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# %pip install py7zr\n",
    "# import py7zr\n",
    "# a = py7zr.SevenZipFile(r'../input/cifar-10/train.7z','r')\n",
    "# a.extractall(path=r'./')\n",
    "# a.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:02.566458Z",
     "iopub.status.busy": "2025-01-21T13:55:02.566278Z",
     "iopub.status.idle": "2025-01-21T13:55:02.685149Z",
     "shell.execute_reply": "2025-01-21T13:55:02.684618Z",
     "shell.execute_reply.started": "2025-01-21T13:55:02.566438Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "04_10_monkeys_model_1_aliyun.ipynb\t\t       runs\n",
      "05_10_monkeys_model_2_resnet50_finetune_2aliyun.ipynb  sampleSubmission.csv\n",
      "06_cifar10_model_2-aliyun.ipynb\t\t\t       submission.csv\n",
      "checkpoints\t\t\t\t\t       test.7z\n",
      "competitions\t\t\t\t\t       train.7z\n",
      "kaggle.json\t\t\t\t\t       trainLabels.csv\n",
      "new-vgg-aliyun.ipynb\n"
     ]
    }
   ],
   "source": [
    "#我们不运行test数据集，太多图片\n",
    "!ls ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:02.686684Z",
     "iopub.status.busy": "2025-01-21T13:55:02.686404Z",
     "iopub.status.idle": "2025-01-21T13:55:02.689222Z",
     "shell.execute_reply": "2025-01-21T13:55:02.688719Z",
     "shell.execute_reply.started": "2025-01-21T13:55:02.686661Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# !mkdir test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:17.556866200Z",
     "start_time": "2024-04-29T02:50:13.332056200Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:02.689998Z",
     "iopub.status.busy": "2025-01-21T13:55:02.689826Z",
     "iopub.status.idle": "2025-01-21T13:55:04.934546Z",
     "shell.execute_reply": "2025-01-21T13:55:04.933985Z",
     "shell.execute_reply.started": "2025-01-21T13:55:02.689980Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(PosixPath('competitions/cifar-10/train/1.png'), 'frog'),\n",
      " (PosixPath('competitions/cifar-10/train/2.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/3.png'), 'truck'),\n",
      " (PosixPath('competitions/cifar-10/train/4.png'), 'deer'),\n",
      " (PosixPath('competitions/cifar-10/train/5.png'), 'automobile')]\n",
      "[(PosixPath('competitions/cifar-10/test/1.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/2.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/3.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/4.png'), 'cat'),\n",
      " (PosixPath('competitions/cifar-10/test/5.png'), 'cat')]\n",
      "50000 300000\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "DATA_DIR = Path(\".\")\n",
    "DATA_DIR1 =Path(\"competitions/cifar-10/\")\n",
    "train_lables_file = DATA_DIR / \"trainLabels.csv\"\n",
    "test_csv_file = DATA_DIR / \"sampleSubmission.csv\" #测试集模板csv文件\n",
    "train_folder = DATA_DIR1 / \"train\"\n",
    "test_folder = DATA_DIR1 / \"test\"\n",
    "\n",
    "#所有的类别\n",
    "class_names = [\n",
    "    'airplane',\n",
    "    'automobile',\n",
    "    'bird',\n",
    "    'cat',\n",
    "    'deer',\n",
    "    'dog',\n",
    "    'frog',\n",
    "    'horse',\n",
    "    'ship',\n",
    "    'truck',\n",
    "]\n",
    "\n",
    "def parse_csv_file(filepath, folder):\n",
    "    \"\"\"Parses csv files into (filename(path), label) format\"\"\"\n",
    "    results = []\n",
    "    #读取所有行\n",
    "    with open(filepath, 'r') as f:\n",
    "#         lines = f.readlines()  为什么加[1:]，可以试这个\n",
    "        #第一行不需要，因为第一行是标签\n",
    "        lines = f.readlines()[1:] \n",
    "    for line in lines:#依次去取每一行\n",
    "        image_id, label_str = line.strip('\\n').split(',')\n",
    "        image_full_path = folder / f\"{image_id}.png\"\n",
    "        results.append((image_full_path, label_str)) #得到对应图片的路径和分类\n",
    "    return results\n",
    "\n",
    "#解析对应的文件夹\n",
    "train_labels_info = parse_csv_file(train_lables_file, train_folder)\n",
    "test_csv_info = parse_csv_file(test_csv_file, test_folder)\n",
    "#打印\n",
    "import pprint\n",
    "pprint.pprint(train_labels_info[0:5])\n",
    "pprint.pprint(test_csv_info[0:5])\n",
    "print(len(train_labels_info), len(test_csv_info))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:22.471835700Z",
     "start_time": "2024-04-29T02:50:22.346907200Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:04.935470Z",
     "iopub.status.busy": "2025-01-21T13:55:04.935202Z",
     "iopub.status.idle": "2025-01-21T13:55:04.991681Z",
     "shell.execute_reply": "2025-01-21T13:55:04.991174Z",
     "shell.execute_reply.started": "2025-01-21T13:55:04.935449Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                            filepath       class\n",
      "0  competitions/cifar-10/train/1.png        frog\n",
      "1  competitions/cifar-10/train/2.png       truck\n",
      "2  competitions/cifar-10/train/3.png       truck\n",
      "3  competitions/cifar-10/train/4.png        deer\n",
      "4  competitions/cifar-10/train/5.png  automobile\n",
      "                                filepath       class\n",
      "0  competitions/cifar-10/train/45001.png       horse\n",
      "1  competitions/cifar-10/train/45002.png  automobile\n",
      "2  competitions/cifar-10/train/45003.png        deer\n",
      "3  competitions/cifar-10/train/45004.png  automobile\n",
      "4  competitions/cifar-10/train/45005.png    airplane\n",
      "                           filepath class\n",
      "0  competitions/cifar-10/test/1.png   cat\n",
      "1  competitions/cifar-10/test/2.png   cat\n",
      "2  competitions/cifar-10/test/3.png   cat\n",
      "3  competitions/cifar-10/test/4.png   cat\n",
      "4  competitions/cifar-10/test/5.png   cat\n"
     ]
    }
   ],
   "source": [
    "# train_df = pd.DataFrame(train_labels_info)\n",
    "train_df = pd.DataFrame(train_labels_info[0:45000])\n",
    "valid_df = pd.DataFrame(train_labels_info[45000:])\n",
    "test_df = pd.DataFrame(test_csv_info)\n",
    "\n",
    "train_df.columns = ['filepath', 'class']\n",
    "valid_df.columns = ['filepath', 'class']\n",
    "test_df.columns = ['filepath', 'class']\n",
    "\n",
    "print(train_df.head())\n",
    "print(valid_df.head())\n",
    "print(test_df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:50:31.586523100Z",
     "start_time": "2024-04-29T02:50:28.504142500Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:04.992494Z",
     "iopub.status.busy": "2025-01-21T13:55:04.992259Z",
     "iopub.status.idle": "2025-01-21T13:55:05.794149Z",
     "shell.execute_reply": "2025-01-21T13:55:05.793618Z",
     "shell.execute_reply.started": "2025-01-21T13:55:04.992473Z"
    }
   },
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms\n",
    "\n",
    "class Cifar10Dataset(Dataset):\n",
    "    df_map = {\n",
    "        \"train\": train_df,\n",
    "        \"eval\": valid_df,\n",
    "        \"test\": test_df\n",
    "    }\n",
    "    label_to_idx = {label: idx for idx, label in enumerate(class_names)}\n",
    "    idx_to_label = {idx: label for idx, label in enumerate(class_names)}\n",
    "    def __init__(self, mode, transform=None):\n",
    "        self.df = self.df_map.get(mode, None)\n",
    "        if self.df is None:\n",
    "            raise ValueError(\"mode should be one of train, val, test, but got {}\".format(mode))\n",
    "\n",
    "        self.transform = transform\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        img_path, label = self.df.iloc[index]\n",
    "        img = Image.open(img_path).convert('RGB')\n",
    "        # # img 转换为 channel first\n",
    "        # img = img.transpose((2, 0, 1))\n",
    "        # transform\n",
    "        img = self.transform(img)\n",
    "        # label 转换为 idx\n",
    "        label = self.label_to_idx[label]\n",
    "        return img, label\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self.df.shape[0]\n",
    "    \n",
    "IMAGE_SIZE = 32\n",
    "mean, std = [0.4914, 0.4822, 0.4465], [0.247, 0.243, 0.261]\n",
    "\n",
    "transforms_train = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        # random rotation 40\n",
    "        transforms.RandomRotation(40),\n",
    "        # horizaontal flip\n",
    "        transforms.RandomHorizontalFlip(),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "transforms_eval = transforms.Compose([\n",
    "        # resize\n",
    "        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean, std)\n",
    "    ])\n",
    "\n",
    "train_ds = Cifar10Dataset(\"train\", transforms_train)\n",
    "eval_ds = Cifar10Dataset(\"eval\", transforms_eval) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:51:31.864180800Z",
     "start_time": "2024-04-29T02:51:31.841167400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:05.795109Z",
     "iopub.status.busy": "2025-01-21T13:55:05.794768Z",
     "iopub.status.idle": "2025-01-21T13:55:05.798339Z",
     "shell.execute_reply": "2025-01-21T13:55:05.797837Z",
     "shell.execute_reply.started": "2025-01-21T13:55:05.795087Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 64\n",
    "train_dl = DataLoader(train_ds, batch_size=batch_size, shuffle=True, num_workers=4)   \n",
    "eval_dl = DataLoader(eval_ds, batch_size=batch_size, shuffle=False, num_workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:19.396136500Z",
     "start_time": "2023-12-05T09:46:43.935044500Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T13:55:05.799083Z",
     "iopub.status.busy": "2025-01-21T13:55:05.798909Z",
     "iopub.status.idle": "2025-01-21T13:55:05.801764Z",
     "shell.execute_reply": "2025-01-21T13:55:05.801271Z",
     "shell.execute_reply.started": "2025-01-21T13:55:05.799064Z"
    }
   },
   "outputs": [],
   "source": [
    "# 遍历train_ds得到每张图片，计算每个通道的均值和方差\n",
    "#这里不需要每次都执行，只需要执行一次就可以了，所以注释掉\n",
    "# def cal_mean_std(ds):\n",
    "#     mean = 0.\n",
    "#     std = 0.\n",
    "#     for img, _ in ds:\n",
    "#         mean += img.mean(dim=(1, 2))\n",
    "#         std += img.std(dim=(1, 2))\n",
    "#     mean /= len(ds)\n",
    "#     std /= len(ds)\n",
    "#     return mean, std\n",
    "#\n",
    "# # 经过 normalize 后 均值为0，方差为1\n",
    "# print(cal_mean_std(train_ds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 定义模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:52:55.126913100Z",
     "start_time": "2024-04-29T02:52:55.080936200Z"
    },
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.427821Z",
     "iopub.status.busy": "2025-01-21T14:15:16.427445Z",
     "iopub.status.idle": "2025-01-21T14:15:16.438474Z",
     "shell.execute_reply": "2025-01-21T14:15:16.438020Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.427793Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             model.0.weight             paramerters num: 864\n",
      "              model.0.bias              paramerters num: 32\n",
      "             model.2.weight             paramerters num: 9216\n",
      "              model.2.bias              paramerters num: 32\n",
      "             model.5.weight             paramerters num: 9216\n",
      "              model.5.bias              paramerters num: 32\n",
      "             model.7.weight             paramerters num: 9216\n",
      "              model.7.bias              paramerters num: 32\n",
      "            model.10.weight             paramerters num: 9216\n",
      "             model.10.bias              paramerters num: 32\n",
      "            model.12.weight             paramerters num: 9216\n",
      "             model.12.bias              paramerters num: 32\n",
      "            model.16.weight             paramerters num: 5120\n",
      "             model.16.bias              paramerters num: 10\n"
     ]
    }
   ],
   "source": [
    "class VGG(nn.Module):\n",
    "    def __init__(self, num_classes):\n",
    "        super().__init__()\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=\"same\"),# 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*32*32\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*16*16\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.Conv2d(in_channels=32, out_channels=32, kernel_size=3, padding=\"same\"),# 32*8*8\n",
    "            nn.ReLU(),\n",
    "            nn.MaxPool2d(kernel_size=2), # 32*4*4\n",
    "            nn.Flatten(),\n",
    "            nn.Linear(512, num_classes),\n",
    "        )\n",
    "        self.init_weights()\n",
    "        \n",
    "    def init_weights(self):\n",
    "        \"\"\"使用 xavier 均匀分布来初始化全连接层、卷积层的权重 W\"\"\"\n",
    "        for m in self.modules():\n",
    "            if isinstance(m, (nn.Linear, nn.Conv2d)):\n",
    "                nn.init.xavier_uniform_(m.weight)\n",
    "                nn.init.zeros_(m.bias)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "        \n",
    "for key, value in VGG(len(class_names)).named_parameters():\n",
    "    print(f\"{key:^40}paramerters num: {np.prod(value.shape)}\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-21T06:41:50.445101Z",
     "start_time": "2025-01-21T06:41:50.441569Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.439519Z",
     "iopub.status.busy": "2025-01-21T14:15:16.439278Z",
     "iopub.status.idle": "2025-01-21T14:15:16.442976Z",
     "shell.execute_reply": "2025-01-21T14:15:16.442489Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.439495Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*4*4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 训练\n",
    "\n",
    "pytorch的训练需要自行实现，包括\n",
    "1. 定义损失函数\n",
    "2. 定义优化器\n",
    "3. 定义训练步\n",
    "4. 训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-07-23T08:24:38.083191700Z",
     "start_time": "2024-07-23T08:24:38.072843500Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.443663Z",
     "iopub.status.busy": "2025-01-21T14:15:16.443480Z",
     "iopub.status.idle": "2025-01-21T14:15:16.446866Z",
     "shell.execute_reply": "2025-01-21T14:15:16.446395Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.443644Z"
    },
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "512"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "32*16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-04-29T02:53:41.778122600Z",
     "start_time": "2024-04-29T02:53:41.736145400Z"
    },
    "collapsed": false,
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.448179Z",
     "iopub.status.busy": "2025-01-21T14:15:16.447875Z",
     "iopub.status.idle": "2025-01-21T14:15:16.453014Z",
     "shell.execute_reply": "2025-01-21T14:15:16.452578Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.448159Z"
    },
    "jupyter": {
     "outputs_hidden": false
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total trainable parameters: 52266\n"
     ]
    }
   ],
   "source": [
    "#模型总参数量\n",
    "total_params = sum(p.numel() for p in VGG(len(class_names)).parameters() if p.requires_grad)\n",
    "print(f\"Total trainable parameters: {total_params}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:19.650361500Z",
     "start_time": "2023-12-05T09:51:19.432189700Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.453684Z",
     "iopub.status.busy": "2025-01-21T14:15:16.453499Z",
     "iopub.status.idle": "2025-01-21T14:15:16.458051Z",
     "shell.execute_reply": "2025-01-21T14:15:16.457607Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.453665Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "@torch.no_grad()\n",
    "def evaluating(model, dataloader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in dataloader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "        # 前向计算\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)         # 验证集损失\n",
    "        loss_list.append(loss.item())\n",
    "        \n",
    "        preds = logits.argmax(axis=-1)    # 验证集预测\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "        \n",
    "    acc = accuracy_score(label_list, pred_list)\n",
    "    return np.mean(loss_list), acc\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### TensorBoard 可视化\n",
    "\n",
    "\n",
    "训练过程中可以使用如下命令启动tensorboard服务。\n",
    "\n",
    "```shell\n",
    "tensorboard \\\n",
    "    --logdir=runs \\     # log 存放路径\n",
    "    --host 0.0.0.0 \\    # ip\n",
    "    --port 8848         # 端口\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.334347900Z",
     "start_time": "2023-12-05T09:51:19.656342Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.458932Z",
     "iopub.status.busy": "2025-01-21T14:15:16.458563Z",
     "iopub.status.idle": "2025-01-21T14:15:16.465522Z",
     "shell.execute_reply": "2025-01-21T14:15:16.465073Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.458912Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "\n",
    "class TensorBoardCallback:\n",
    "    def __init__(self, log_dir, flush_secs=10):\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            log_dir (str): dir to write log.\n",
    "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
    "        \"\"\"\n",
    "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs)\n",
    "\n",
    "    def draw_model(self, model, input_shape):\n",
    "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape))\n",
    "        \n",
    "    def add_loss_scalars(self, step, loss, val_loss):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/loss\", \n",
    "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
    "            global_step=step,\n",
    "            )\n",
    "        \n",
    "    def add_acc_scalars(self, step, acc, val_acc):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/accuracy\",\n",
    "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
    "            global_step=step,\n",
    "        )\n",
    "        \n",
    "    def add_lr_scalars(self, step, learning_rate):\n",
    "        self.writer.add_scalars(\n",
    "            main_tag=\"training/learning_rate\",\n",
    "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
    "            global_step=step,\n",
    "            \n",
    "        )\n",
    "    \n",
    "    def __call__(self, step, **kwargs):\n",
    "        # add loss\n",
    "        loss = kwargs.pop(\"loss\", None)\n",
    "        val_loss = kwargs.pop(\"val_loss\", None)\n",
    "        if loss is not None and val_loss is not None:\n",
    "            self.add_loss_scalars(step, loss, val_loss)\n",
    "        # add acc\n",
    "        acc = kwargs.pop(\"acc\", None)\n",
    "        val_acc = kwargs.pop(\"val_acc\", None)\n",
    "        if acc is not None and val_acc is not None:\n",
    "            self.add_acc_scalars(step, acc, val_acc)\n",
    "        # add lr\n",
    "        learning_rate = kwargs.pop(\"lr\", None)\n",
    "        if learning_rate is not None:\n",
    "            self.add_lr_scalars(step, learning_rate)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save Best\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.347424300Z",
     "start_time": "2023-12-05T09:51:26.337347300Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.466252Z",
     "iopub.status.busy": "2025-01-21T14:15:16.466035Z",
     "iopub.status.idle": "2025-01-21T14:15:16.471122Z",
     "shell.execute_reply": "2025-01-21T14:15:16.470716Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.466233Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=5000, save_best_only=True):\n",
    "        \"\"\"\n",
    "        Save checkpoints each save_epoch epoch. \n",
    "        We save checkpoint by epoch in this implementation.\n",
    "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
    "\n",
    "        Args:\n",
    "            save_dir (str): dir to save checkpoint\n",
    "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
    "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
    "        \"\"\"\n",
    "        self.save_dir = save_dir\n",
    "        self.save_step = save_step\n",
    "        self.save_best_only = save_best_only\n",
    "        self.best_metrics = -1\n",
    "        \n",
    "        # mkdir\n",
    "        if not os.path.exists(self.save_dir):\n",
    "            os.mkdir(self.save_dir)\n",
    "        \n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return\n",
    "        \n",
    "        if self.save_best_only:\n",
    "            assert metric is not None\n",
    "            if metric >= self.best_metrics:\n",
    "                # save checkpoints\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                # update best metrics\n",
    "                self.best_metrics = metric\n",
    "        else:\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Early Stop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-12-05T09:51:26.371402100Z",
     "start_time": "2023-12-05T09:51:26.351411800Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.471952Z",
     "iopub.status.busy": "2025-01-21T14:15:16.471660Z",
     "iopub.status.idle": "2025-01-21T14:15:16.475875Z",
     "shell.execute_reply": "2025-01-21T14:15:16.475448Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.471933Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        \"\"\"\n",
    "\n",
    "        Args:\n",
    "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
    "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute \n",
    "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
    "        \"\"\"\n",
    "        self.patience = patience\n",
    "        self.min_delta = min_delta\n",
    "        self.best_metric = -1\n",
    "        self.counter = 0\n",
    "        \n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:\n",
    "            # update best metric\n",
    "            self.best_metric = metric\n",
    "            # reset counter \n",
    "            self.counter = 0\n",
    "        else: \n",
    "            self.counter += 1\n",
    "            \n",
    "    @property\n",
    "    def early_stop(self):\n",
    "        return self.counter >= self.patience\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "start_time": "2023-12-05T09:51:26.364406400Z"
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:15:16.477544Z",
     "iopub.status.busy": "2025-01-21T14:15:16.477309Z",
     "iopub.status.idle": "2025-01-21T14:16:31.588008Z",
     "shell.execute_reply": "2025-01-21T14:16:31.587391Z",
     "shell.execute_reply.started": "2025-01-21T14:15:16.477525Z"
    },
    "is_executing": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 7040/7040 [01:15<00:00, 93.86it/s, epoch=9] \n"
     ]
    }
   ],
   "source": [
    "# 训练\n",
    "def training(\n",
    "    model, \n",
    "    train_loader, \n",
    "    val_loader, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=None,\n",
    "    early_stop_callback=None,\n",
    "    eval_step=500,\n",
    "    ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "    \n",
    "    global_step = 0\n",
    "    model.train()\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            # training\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "                # 梯度清空\n",
    "                optimizer.zero_grad()\n",
    "                # 模型前向计算\n",
    "                logits = model(datas)\n",
    "                # 计算损失\n",
    "                loss = loss_fct(logits, labels)\n",
    "                # 梯度回传\n",
    "                loss.backward()\n",
    "                # 调整优化器，包括学习率的变动等\n",
    "                optimizer.step()\n",
    "                preds = logits.argmax(axis=-1)\n",
    "            \n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())    \n",
    "                loss = loss.cpu().item()\n",
    "                # record\n",
    "                \n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
    "                })\n",
    "                \n",
    "                # evaluating\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()\n",
    "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
    "                    })\n",
    "                    model.train()\n",
    "                    \n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step, \n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],\n",
    "                            )\n",
    "                \n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc)\n",
    "\n",
    "                    # 3. 早停 Early Stop\n",
    "                    if early_stop_callback is not None:\n",
    "                        early_stop_callback(val_acc)\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict\n",
    "                    \n",
    "                # udate step\n",
    "                global_step += 1\n",
    "                pbar.update(1)\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "        \n",
    "    return record_dict\n",
    "        \n",
    "\n",
    "epoch = 10\n",
    "\n",
    "model = VGG(num_classes=10)\n",
    "\n",
    "# 1. 定义损失函数 采用交叉熵损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "# 2. 定义优化器 采用 adam\n",
    "# Optimizers specified in the torch.optim package\n",
    "#可以修改adam里边的weight_decay参数，来控制L2正则化的程度,beta1和beta2是指数衰减率\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "# 1. tensorboard 可视化\n",
    "if not os.path.exists(\"runs\"):\n",
    "    os.mkdir(\"runs\")\n",
    "tensorboard_callback = TensorBoardCallback(\"runs/vgg\")\n",
    "tensorboard_callback.draw_model(model, [1, 3, IMAGE_SIZE, IMAGE_SIZE])\n",
    "# 2. save best\n",
    "if not os.path.exists(\"checkpoints\"):\n",
    "    os.makedirs(\"checkpoints\")\n",
    "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints/vgg\", save_step=len(train_dl), save_best_only=True)\n",
    "# 3. early stop\n",
    "early_stop_callback = EarlyStopCallback(patience=5)\n",
    "\n",
    "model = model.to(device)\n",
    "record = training(\n",
    "    model, \n",
    "    train_dl, \n",
    "    eval_dl, \n",
    "    epoch, \n",
    "    loss_fct, \n",
    "    optimizer, \n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=len(train_dl)\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T14:17:18.402851Z",
     "iopub.status.busy": "2025-01-21T14:17:18.402485Z",
     "iopub.status.idle": "2025-01-21T14:17:18.644233Z",
     "shell.execute_reply": "2025-01-21T14:17:18.643608Z",
     "shell.execute_reply.started": "2025-01-21T14:17:18.402826Z"
    },
    "is_executing": true,
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#画线要注意的是损失是不一定在零到1之间的\n",
    "def plot_learning_curves(record_dict, sample_step=500):\n",
    "    # build DataFrame\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    # plot\n",
    "    fig_num = len(train_df.columns)\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):    \n",
    "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
    "        axs[idx].grid()\n",
    "        axs[idx].legend()\n",
    "        # axs[idx].set_xticks(range(0, train_df.index[-1], 5000))\n",
    "        # axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", range(0, train_df.index[-1], 5000)))\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "    \n",
    "    plt.show()\n",
    "\n",
    "plot_learning_curves(record, sample_step=100)  #横坐标是 steps"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 评估"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecutionIndicator": {
     "show": true
    },
    "execution": {
     "iopub.execute_input": "2025-01-21T14:17:20.927122Z",
     "iopub.status.busy": "2025-01-21T14:17:20.926773Z",
     "iopub.status.idle": "2025-01-21T14:17:21.653882Z",
     "shell.execute_reply": "2025-01-21T14:17:21.653295Z",
     "shell.execute_reply.started": "2025-01-21T14:17:20.927099Z"
    },
    "is_executing": true,
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loss:     0.8539\n",
      "accuracy: 0.7106\n"
     ]
    }
   ],
   "source": [
    "# dataload for evaluating\n",
    "\n",
    "# load checkpoints\n",
    "model.load_state_dict(torch.load(\"checkpoints/vgg/best.ckpt\",weights_only=True, map_location=\"cpu\"))\n",
    "\n",
    "model.eval()\n",
    "loss, acc = evaluating(model, eval_dl, loss_fct)\n",
    "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 推理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T14:16:32.478910Z",
     "iopub.status.busy": "2025-01-21T14:16:32.478646Z",
     "iopub.status.idle": "2025-01-21T14:16:32.481694Z",
     "shell.execute_reply": "2025-01-21T14:16:32.481237Z",
     "shell.execute_reply.started": "2025-01-21T14:16:32.478885Z"
    },
    "is_executing": true
   },
   "outputs": [],
   "source": [
    "# # test_df\n",
    "# test_ds = Cifar10Dataset(\"test\", transform=transforms_eval)\n",
    "# test_dl = DataLoader(test_ds, batch_size=batch_size, shuffle=False, drop_last=False)\n",
    "#\n",
    "# preds_collect = []\n",
    "# model.eval()\n",
    "# for data, fake_label in tqdm(test_dl):\n",
    "#     data = data.to(device=device)\n",
    "#     logits = model(data)\n",
    "#     preds = [test_ds.idx_to_label[idx] for idx in logits.argmax(axis=-1).cpu().tolist()]\n",
    "#     preds_collect.extend(preds)\n",
    "#\n",
    "# test_df[\"class\"] = preds_collect\n",
    "# test_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2025-01-21T14:16:32.482453Z",
     "iopub.status.busy": "2025-01-21T14:16:32.482266Z",
     "iopub.status.idle": "2025-01-21T14:16:32.484797Z",
     "shell.execute_reply": "2025-01-21T14:16:32.484346Z",
     "shell.execute_reply.started": "2025-01-21T14:16:32.482434Z"
    },
    "is_executing": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "# # 导出 submission.csv\n",
    "# test_df.to_csv(\"submission.csv\", index=False)"
   ]
  }
 ],
 "metadata": {
  "kaggle": {
   "accelerator": "gpu",
   "dataSources": [
    {
     "databundleVersionId": 46718,
     "sourceId": 3649,
     "sourceType": "competition"
    }
   ],
   "dockerImageVersionId": 30588,
   "isGpuEnabled": true,
   "isInternetEnabled": true,
   "language": "python",
   "sourceType": "notebook"
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
